/* -------------------------------------------------------------------------
 *
 * tupmacs.h
 *	  Tuple macros used by both index tuples and heap tuples.
 *
 *
 * Portions Copyright (c) 1996-2012, PostgreSQL Global Development Group
 * Portions Copyright (c) 1994, Regents of the University of California
 *
 * src/include/access/tupmacs.h
 *
 * -------------------------------------------------------------------------
 */
#ifndef TUPMACS_H
#define TUPMACS_H

/*
 * check to see if the ATT'th bit of an array of 8-bit bytes is set.
 */
#define att_isnull(ATT, BITS) (!((BITS)[(uint32)(int32)(ATT) >> 3] & (1 << ((ATT)&0x07))))

/*
 * Given a Form_pg_attribute and a pointer into a tuple's data area,
 * return the correct value or pointer.
 *
 * We return a Datum value in all cases.  If the attribute has "byval" false,
 * we return the same pointer into the tuple data area that we're passed.
 * Otherwise, we return the correct number of bytes fetched from the data
 * area and extended to Datum form.
 *
 * On machines where Datum is 8 bytes, we support fetching 8-byte byval
 * attributes; otherwise, only 1, 2, and 4-byte values are supported.
 *
 * Note that T must already be properly aligned for this to work correctly.
 */
#define fetchatt(A, T) fetch_att(T, (A)->attbyval, (A)->attlen)

/*
 * Same, but work from byval/len parameters rather than Form_pg_attribute.
 */
#if SIZEOF_DATUM == 8

#define fetch_att(T, attbyval, attlen)                                                                       \
    ((attbyval) ? ((attlen) == (int)sizeof(Datum)                                                            \
                          ? *((Datum*)(T))                                                                   \
                          : ((attlen) == (int)sizeof(int32)                                                  \
                                    ? Int32GetDatum(*((int32*)(T)))                                          \
                                    : ((attlen) == (int)sizeof(int16)                                        \
                                              ? Int16GetDatum(*((int16*)(T)))                                \
                                              : (AssertMacro((attlen) == 1), CharGetDatum(*((char*)(T))))))) \
                : PointerGetDatum((char*)(T)))
#else /* SIZEOF_DATUM != 8 */

#define fetch_att(T, attbyval, attlen)                                                                                \
    ((attbyval)                                                                                                       \
            ? ((attlen) == (int)sizeof(int32)                                                                         \
                      ? Int32GetDatum(*((int32*)(T)))                                                                 \
                      : ((attlen) == (int)sizeof(int16) ? Int16GetDatum(*((int16*)(T)))                               \
                                                        : (AssertMacro((attlen) == 1), CharGetDatum(*((char*)(T)))))) \
            : PointerGetDatum((char*)(T)))
#endif /* SIZEOF_DATUM == 8 */

/*
 * att_align_datum aligns the given offset as needed for a datum of alignment
 * requirement attalign and typlen attlen.	attdatum is the Datum variable
 * we intend to pack into a tuple (it's only accessed if we are dealing with
 * a varlena type).  Note that this assumes the Datum will be stored as-is;
 * callers that are intending to convert non-short varlena datums to short
 * format have to account for that themselves.
 */
#define att_align_datum(cur_offset, attalign, attlen, attdatum)                              \
    (((attlen) == -1 && (VARATT_IS_SHORT(DatumGetPointer(attdatum)) || VARATT_IS_HUGE_TOAST_POINTER(DatumGetPointer(attdatum)) )) ? (intptr_t)(cur_offset) \
                                                                    : att_align_nominal(cur_offset, attalign))

/*
 * att_align_pointer performs the same calculation as att_align_datum,
 * but is used when walking a tuple.  attptr is the current actual data
 * pointer; when accessing a varlena field we have to "peek" to see if we
 * are looking at a pad byte or the first byte of a 1-byte-header datum.
 * (A zero byte must be either a pad byte, or the first byte of a correctly
 * aligned 4-byte length word; in either case we can align safely.	A non-zero
 * byte must be either a 1-byte length word, or the first byte of a correctly
 * aligned 4-byte length word; in either case we need not align.)
 *
 * Note: some callers pass a "char *" pointer for cur_offset.  This is
 * a bit of a hack but should work all right as long as intptr_t is the
 * correct width.
 */
#define att_align_pointer(cur_offset, attalign, attlen, attptr) \
    (((attlen) == -1 && VARATT_NOT_PAD_BYTE(attptr)) ? (intptr_t)(cur_offset) : att_align_nominal(cur_offset, attalign))

/*
 * att_align_nominal aligns the given offset as needed for a datum of alignment
 * requirement attalign, ignoring any consideration of packed varlena datums.
 * There are three main use cases for using this macro directly:
 *	* we know that the att in question is not varlena (attlen != -1);
 *	  in this case it is cheaper than the above macros and just as good.
 *	* we need to estimate alignment padding cost abstractly, ie without
 *	  reference to a real tuple.  We must assume the worst case that
 *	  all varlenas are aligned.
 *	* within arrays, we unconditionally align varlenas (XXX this should be
 *	  revisited, probably).
 *
 * The attalign cases are tested in what is hopefully something like their
 * frequency of occurrence.
 */
#define att_align_nominal(cur_offset, attalign)                        \
    (((attalign) == 'i')                                               \
            ? INTALIGN(cur_offset)                                     \
            : (((attalign) == 'c')                                     \
                      ? (uintptr_t)(cur_offset)                        \
                      : (((attalign) == 'd') ? DOUBLEALIGN(cur_offset) \
                                             : (AssertMacro((attalign) == 's'), SHORTALIGN(cur_offset)))))

/*
 * att_addlength_datum increments the given offset by the space needed for
 * the given Datum variable.  attdatum is only accessed if we are dealing
 * with a variable-length attribute.
 */
#define att_addlength_datum(cur_offset, attlen, attdatum) \
    att_addlength_pointer(cur_offset, attlen, DatumGetPointer(attdatum))

/*
 * att_addlength_pointer performs the same calculation as att_addlength_datum,
 * but is used when walking a tuple --- attptr is the pointer to the field
 * within the tuple.
 *
 * Note: some callers pass a "char *" pointer for cur_offset.  This is
 * actually perfectly OK, but probably should be cleaned up along with
 * the same practice for att_align_pointer.
 */
#define att_addlength_pointer(cur_offset, attlen, attptr)              \
    (((attlen) > 0)                                                    \
            ? ((cur_offset) + (attlen))                                \
            : (((attlen) == -1) ? ((cur_offset) + VARSIZE_ANY(attptr)) \
                                : (AssertMacro((attlen) == -2), (cur_offset) + (strlen((char*)(attptr)) + 1))))

/*
 * store_att_byval is a partial inverse of fetch_att: store a given Datum
 * value into a tuple data area at the specified address.  However, it only
 * handles the byval case, because in typical usage the caller needs to
 * distinguish by-val and by-ref cases anyway, and so a do-it-all macro
 * wouldn't be convenient.
 */
#if SIZEOF_DATUM == 8

#define store_att_byval(T, newdatum, attlen)                                \
    do {                                                                    \
        switch (attlen) {                                                   \
            case sizeof(char):                                              \
                *(char*)(T) = DatumGetChar(newdatum);                       \
                break;                                                      \
            case sizeof(int16):                                             \
                *(int16*)(T) = DatumGetInt16(newdatum);                     \
                break;                                                      \
            case sizeof(int32):                                             \
                *(int32*)(T) = DatumGetInt32(newdatum);                     \
                break;                                                      \
            case sizeof(Datum):                                             \
                *(Datum*)(T) = (newdatum);                                  \
                break;                                                      \
            default:                                                        \
                elog(ERROR, "unsupported byval length: %d", (int)(attlen)); \
                break;                                                      \
        }                                                                   \
    } while (0)
#else /* SIZEOF_DATUM != 8 */

#define store_att_byval(T, newdatum, attlen)                                \
    do {                                                                    \
        switch (attlen) {                                                   \
            case sizeof(char):                                              \
                *(char*)(T) = DatumGetChar(newdatum);                       \
                break;                                                      \
            case sizeof(int16):                                             \
                *(int16*)(T) = DatumGetInt16(newdatum);                     \
                break;                                                      \
            case sizeof(int32):                                             \
                *(int32*)(T) = DatumGetInt32(newdatum);                     \
                break;                                                      \
            default:                                                        \
                elog(ERROR, "unsupported byval length: %d", (int)(attlen)); \
                break;                                                      \
        }                                                                   \
    } while (0)
#endif /* SIZEOF_DATUM == 8 */

#endif
